/**
 * 运费计算系统的工具函数
 * @author 运费系统团队
 * @version 3.1.0 - 修复ES6语法兼容性问题
 */

// 版本标识，确保浏览器加载最新版本
console.log('🔧 Utils.js v3.1.0 已加载 - 支持浏览器直接加载');

// 使用全局对象，兼容浏览器直接加载
window.Utils = {
    /**
     * 清除所有消息显示
     */
    clearMessages() {
        const errorElements = document.querySelectorAll('.error');
        const successElements = document.querySelectorAll('.success');
        errorElements.forEach(el => el.style.display = 'none');
        successElements.forEach(el => el.style.display = 'none');
    },

    /**
     * 向用户显示消息
     * @param {string} message - 消息内容
     * @param {boolean} isError - 是否是错误消息
     */
    showMessage(message, isError = false) {
        this.clearMessages();
        
        // 创建消息元素
        const messageEl = document.createElement('div');
        messageEl.className = isError ? 'error' : 'success';
        messageEl.textContent = message;
        
        // 查找内容区域并插入消息
        const contentArea = document.querySelector('.content-area');
        if (contentArea) {
            contentArea.insertBefore(messageEl, contentArea.firstChild);
        }
        
        // 3秒后自动隐藏
        setTimeout(() => {
            if (messageEl.parentNode) {
                messageEl.parentNode.removeChild(messageEl);
            }
        }, 3000);
    },

    /**
     * 格式化区域名称用于显示
     * @param {Object} area - 区域对象
     * @returns {string} 格式化后的区域名称
     */
    formatAreaName(area) {
        if (!area) return '未知区域';
        
        // 支持多种区域名称字段，按优先级进行回退
        const getFieldValue = (area, fieldNames) => {
            for (const fieldName of fieldNames) {
                const value = area[fieldName];
                if (value && typeof value === 'string' && value.trim()) {
                    return value.trim();
                }
            }
            return null;
        };
        
        let name = '';
        
        // 省份名称 - 支持多种字段回退
        const provinceName = getFieldValue(area, [
            'provinceName', 'province_name', 'name', 'fullName', 'areaName'
        ]);
        
        if (provinceName) {
            name = provinceName;
        } else {
            name = '未知省份';
        }
        
        // 城市名称 - 支持多种字段回退  
        const cityName = getFieldValue(area, [
            'cityName', 'city_name', 'name', 'fullName', 'areaName'
        ]);
        
        if (cityName && cityName !== provinceName) {
            name += '-' + cityName;
        }
        
        // 区县名称 - 支持多种字段回退
        const districtName = getFieldValue(area, [
            'districtName', 'district_name', 'name', 'fullName', 'areaName'
        ]);
        
        if (districtName && districtName !== cityName && districtName !== provinceName) {
            name += '-' + districtName;
        }
        
        return name || '未知区域';
    },

    /**
     * 格式化日期字符串用于显示
     * @param {string} dateString - ISO日期字符串
     * @returns {string} 格式化后的日期
     */
    formatDate(dateString) {
        if (!dateString) return '-';
        return new Date(dateString).toLocaleString('zh-CN');
    },

    /**
     * 防抖函数调用
     * @param {Function} func - 要防抖的函数
     * @param {number} wait - 等待时间（毫秒）
     * @returns {Function} 防抖后的函数
     */
    debounce(func, wait) {
        let timeout;
        return function executedFunction(...args) {
            const later = () => {
                clearTimeout(timeout);
                func(...args);
            };
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
        };
    },

    /**
     * 验证表单数据
     * @param {Object} formData - 要验证的表单数据
     * @param {Array} requiredFields - 必填字段名数组
     * @returns {Object} 验证结果 {isValid: boolean, errors: Array}
     */
    validateForm(formData, requiredFields) {
        const errors = [];
        
        requiredFields.forEach(field => {
            if (!formData[field] || formData[field] === '') {
                errors.push(`${field}不能为空`);
            }
        });
        
        return {
            isValid: errors.length === 0,
            errors
        };
    },

    /**
     * 深度克隆对象
     * @param {Object} obj - 要克隆的对象
     * @returns {Object} 克隆后的对象
     */
    deepClone(obj) {
        if (obj === null || typeof obj !== 'object') return obj;
        if (obj instanceof Date) return new Date(obj.getTime());
        if (obj instanceof Array) return obj.map(item => this.deepClone(item));
        if (typeof obj === 'object') {
            const clonedObj = {};
            for (const key in obj) {
                if (obj.hasOwnProperty(key)) {
                    clonedObj[key] = this.deepClone(obj[key]);
                }
            }
            return clonedObj;
        }
    },

    /**
     * 检查对象是否为空
     * @param {Object} obj - 要检查的对象
     * @returns {boolean} 如果为空则返回true
     */
    isEmpty(obj) {
        if (!obj) return true;
        if (Array.isArray(obj)) return obj.length === 0;
        return Object.keys(obj).length === 0;
    },

    /**
     * 生成唯一ID
     * @returns {string} 唯一ID
     */
    generateId() {
        return Math.random().toString(36).substr(2, 9);
    },

    /**
     * 安全数字转换
     * @param {any} value - 要转换的值
     * @param {number} defaultValue - 转换失败时的默认值
     * @returns {number} 转换后的数字
     */
    toNumber(value, defaultValue = 0) {
        const num = Number(value);
        return isNaN(num) ? defaultValue : num;
    },

    /**
     * 安全字符串转换
     * @param {any} value - 要转换的值
     * @returns {string} 字符串值
     */
    toString(value) {
        if (value === null || value === undefined) return '';
        return String(value);
    }
};

// 全局错误处理工具
window.ErrorHandler = {
    /**
     * 初始化全局错误处理
     */
    init() {
        // 处理全局JavaScript错误
        window.addEventListener('error', (event) => {
            if (this.isApplicationError(event)) {
                console.error('应用程序错误:', event.error);
                Utils.showMessage('应用程序发生错误，请刷新页面重试', true);
            }
        });

        // 处理未处理的Promise拒绝
        window.addEventListener('unhandledrejection', (event) => {
            console.error('未处理的Promise拒绝:', event.reason);
            Utils.showMessage('请求处理失败，请重试', true);
            event.preventDefault();
        });
    },

    /**
     * 检查错误是否来自我们的应用
     * @param {ErrorEvent} event - 错误事件
     * @returns {boolean} 如果是应用错误则返回true
     */
    isApplicationError(event) {
        if (!event.filename) return false;
        return event.filename.includes('index.html') || 
               event.filename.includes('localhost') ||
               event.filename.includes('app.js') ||
               event.filename.includes('api.js');
    },

    /**
     * 处理API错误
     * @param {Error} error - 错误对象
     * @returns {string} 用户友好的错误消息
     */
    handleApiError(error) {
        if (error.response) {
            // 服务器响应错误状态
            const status = error.response.status;
            const message = error.response.data?.msg || error.response.data?.message;
            
            if (status === 400) return message || '请求参数错误';
            if (status === 401) return '未授权访问';
            if (status === 403) return '访问被拒绝';
            if (status === 404) return '请求的资源不存在';
            if (status === 500) return '服务器内部错误';
            
            return message || `请求失败(${status})`;
        } else if (error.request) {
            // 网络错误
            return '网络连接失败，请检查网络设置';
        } else {
            // 其他错误
            return error.message || '未知错误';
        }
    }
};

// 控制台工具
window.ConsoleUtils = {
    /**
     * 清除控制台并显示应用信息
     */
    showAppInfo() {
        if (typeof console !== 'undefined' && console.clear) {
            setTimeout(() => {
                console.clear();
                console.log('%c运费快速计算系统已启动', 'color: #409eff; font-size: 16px; font-weight: bold;');
                console.log('%c开发环境已就绪', 'color: #67c23a;');
                console.log('%c注意: 如果看到与 stadium.js、iframe.js 或 user.js 相关的错误，这些是浏览器扩展程序导致的，不影响应用功能。', 'color: #f56c6c;');
            }, 1000);
        }
    },

    /**
     * 显示帮助信息
     */
    showHelp() {
        setTimeout(() => {
            console.log('%c使用帮助', 'color: #409eff; font-weight: bold;');
            console.log('如需清理控制台，可以按 Ctrl+L 或 Cmd+K');
            console.log('如果遇到问题，请检查网络连接和服务器状态');
        }, 2000);
    }
};

// ES6 模块导出（兼容模块加载方式）
if (typeof module !== 'undefined' && module.exports) {
    // Node.js 环境
    module.exports = {
        Utils: window.Utils,
        ErrorHandler: window.ErrorHandler,
        ConsoleUtils: window.ConsoleUtils
    };
} else if (typeof window !== 'undefined') {
    // 浏览器环境 - ES6 模块导出
    if (typeof exports === 'undefined') {
        window.exports = {};
    }
    
    // 导出主要对象供ES6 import使用
    window.exports.Utils = window.Utils;
    window.exports.ErrorHandler = window.ErrorHandler;
    window.exports.ConsoleUtils = window.ConsoleUtils;
    
    // 特别暴露formatAreaName方法到全局，供其他模块调用
    window.formatAreaName = window.Utils.formatAreaName;
    
    // 暴露其他常用方法
    window.showMessage = window.Utils.showMessage;
    window.clearMessages = window.Utils.clearMessages;
    
    console.log('✅ Utils工具方法已暴露到全局作用域和ES6导出');
}

// 为了支持ES6 import语法，在全局范围内提供导出
if (typeof window !== 'undefined') {
    // 模拟ES6模块导出
    window.__ES6_EXPORTS__ = window.__ES6_EXPORTS__ || {};
    window.__ES6_EXPORTS__['./utils.js'] = {
        default: window.Utils,
        Utils: window.Utils,
        ErrorHandler: window.ErrorHandler,
        ConsoleUtils: window.ConsoleUtils
    };
}